import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:数组的定义与使用
 * User: liangyuanzhang
 * Date: 2024-12-01
 * Time: 12:18
 */
public class Test {
    public static void main(String[] args) {
        int[][] array = new int[2][];//Java当中可以不写列（不规则二维数组）
        array[0] = new int[3];
        array[1] = new int[5];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("==========");
    }
    public static void main21(String[] args) {
        int[][] array = {{1,2,3},{4,5,6}};
/*        System.out.println(array.length);//行数

        System.out.println(array[0].length);
        System.out.println(array[1].length);

        System.out.println(Arrays.toString(array[0]));
        System.out.println(Arrays.toString(array[1]));*/

        //二维数组就是特殊的一维数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("==========");

        for (int[] temArray: array) {//array 的每个元素给到 temArray
            for (int x: temArray) {
                System.out.print(x+" ");
            }
            System.out.println();
        }
        System.out.println("=========");
        
        //String ret = Arrays.toString(array);
        String ret = Arrays.deepToString(array);
        System.out.println(ret);
        
        int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
        int[][] array3 = new int[2][3];


        int[][] array4 = new int[2][];//Java当中可以不写列（不规则二维数组）
     }







    public static void main20(String[] args) {
        int[] array1 = {1,2,31,4,15};
        int[] array2 = {1,2,31,4,15};
        boolean flg = Arrays.equals(array1,array2);//比较两个数组数据一不一样
        System.out.println(flg);//一样

        int[] ret = new int[10];
        Arrays.fill(ret,1,3,-1);//将指定位置给到指定元素
        System.out.println(Arrays.toString(ret));
    }
    public static void main19(String[] args) {
        int[] array = {1,2,31,4,15};
        int[] copy = Arrays.copyOf(array,array.length);//Java方法实现拷贝
        System.out.println(Arrays.toString(copy));

        int[] copy1 = Arrays.copyOf(array,array.length*2);//数组java扩容
        System.out.println(Arrays.toString(copy1));

        int[] copy3 = Arrays.copyOfRange(array,1,3);//拷贝从1--3（不包含3下标）
        System.out.println(Arrays.toString(copy3));
    }
    public static int[] copyArray(int[] array){//数组的拷贝(自己实现)
        int[] copy = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        return copy;
    }
    public static void main18(String[] args) {
        int[] array = {1,2,31,4,15};
        int[] copy = copyArray(array);
        System.out.println(Arrays.toString(copy));
    }
    public static void bubbleSort(int[] array){
        //i 代表趟数
        for (int i = 0; i < array.length; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] >array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            if(flg == false){
                return;
            }
        }
    }
    public static void main17(String[] args) {
        int[] array = {1,2,31,4,15};
        System.out.println("排序前的数组:"+Arrays.toString(array));
        bubbleSort(array);//从小到大排序
        System.out.println("排序后的数组:"+Arrays.toString(array));
    }
    public static void main16(String[] args) {
        int[] array = {1,2,31,4,15};
        System.out.println("排序前的数组："+Arrays.toString(array));
        Arrays.sort(array);//默认从小到大排序
        System.out.println("排序后的数据："+Arrays.toString(array));

        int index = Arrays.binarySearch(array,2);//Java自带的二分查找
        System.out.println(index);
    }
    //针对无需的数组 --> 先排序然后再使用二分查找
    public static void main15(String[] args) {
        int[] array = {1,2,31,4,15};
        Arrays.sort(args);
        System.out.println("排序后的数组:"+Arrays.toString(array));
        //排序完成后再进行二分查找
        int index = binarySearch(array,31);
        System.out.println(index);
    }
    //二分查找->必须是有序的数组
    public static int binarySearch(int[] array,int key){
        int left = 0;
        int right = array.length-1;
        while(left <= right){
            int mid = (left+right)/2;
            if(array[mid] == key){
                return mid;
            }else if(array[mid] > key) {
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
        //走到这还么找到直接返回-1
        return -1;
    }
    public static void main14(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(binarySearch(array,2));
    }
    //查找数组中指定元素（顺序查找）
    /*
    查找效率 比较低 因为 他是 挨个查找
     */
    public static int findNum(int[] array,int key){
        for (int i = 0; i < array.length; i++) {
            if(array[i] == key){
                return i;
            }
        }
        return -1;
    }
    public static void main13(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(findNum(array,3));//3在2下标 -- 找不到就是-1
    }
    public static String myToString(int[] array){//将数组以字符串的形式输出
        String ret = "[";

        for (int i = 0; i < array.length; i++) {
            ret = ret + array[i];
            if(i!=array.length-1)
                ret = ret + ", ";
        }
        ret = ret + "]";
        return ret;
    }
    public static void main12(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(myToString(array));
    }
    public static void ToString(int[] array) {//将数组转换成字符串输出的样子-->本质不是字符串
        System.out.print('[');
        for (int i = 0; i < array.length; i++) {
            if(i==array.length-1){
                System.out.print(array[i]);
            }
            else{
                System.out.print(array[i]+", ");
            }
        }
        System.out.print(']');
    }
    public static void main11(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10,11,12};
        ToString(array);
    }
    public static void funcc2(int[] array){
        array = new int[]{9,8,7,6,5};
    }

    public static void main10(String[] args) {
        int[] array = {1,2,3,4,5};//自己指向新的对象 --> 一个引用不能同时指向多个对象
        funcc2(array);
        System.out.println(Arrays.toString(array));
    }
    public static void funcc1(int[] array){//通过引用改变对象的值
        array[0] = 99;
    }
    public static void main9(String[] args) {
        int[] array = {1,2,3,4,5};
        funcc1(array);
        System.out.println(Arrays.toString(array));
    }
    public static void func2(int[] array){
        /*
        传引用不一定改变形参的值
         */
        //需求：把数组当中的每个数据 扩大2倍 --> 对 对象进行修改
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] * 2;
        }
    }
    public static void main8(String[] args) {
        int[] array = {1,2,3,4,5,6};
        func2(array);
        System.out.println(Arrays.toString(array));
    }
    public static int[] func1(int[] array){
        //需求：把数组当中的每个数据 扩大2倍
        int[] ret = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            ret[i] = array[i] * 2;
        }
        return ret;
    }
    public static void main7(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(func1(array)));
    }

    public static void main6(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] array2 = null;//array2这个引用不指向任何对象
        System.out.println(array2.length);//NullPointerException 空指针（翻译）异常 -- Java无指针概念
        // .前面不能是null
        /*
        如果将来代码 报错 空指针异常，那么我们要做的是 找到这行代码中的 引用。
        判断这个引用为什么是空的
         */
    }
    public static void main5(String[] args) {
        /*
         引用 --> 对象
         array 这个引用 指向了一个对象
         当2个引用指向一个对象的时候，通过任何一个引用，都能修改这个对象的值
         */
        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30;
        int[] array2 = new int[]{1,2,3,4,5};
        array2[0] = 100;
        array2[1] = 200;
        array1 = array2;
        array1[2] = 300;
        array1[3] = 400;
        array2[4] = 500;
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
    }
    public static void main4(String[] args) {
        /*
                //引用 --> 对象
                //array 这个引用 指向了一个对象
                当2个引用指向一个对象的时候，通过任何一个引用，都能修改这个对象的值
         */
        int[] array = {1,2,3,4,5};
        String ret = Arrays.toString(array);
        System.out.println(ret);
    }
    public static void main3(String[] args) {
        //数组的遍历
        int[] array = {1,2,3,4,5,6};
        for (int i = 0; i < array.length; i++) { // 通过 array.length 可以求数组的长度
            System.out.print(array[i] + " ");
        }
        System.out.println();
        System.out.println("—————————————————————————————————");
        //for each循环
        //无法获取到 i 对应的下标
        for (int x : array) {
            System.out.print(x+" ");
        }
        System.out.println();
        System.out.println("——————————————Arrays—————————————");
        //操作数组的工具类 Arrays
        String ret = Arrays.toString(array);//使用Array的String方法啊，把传入的参数array,表示的数组以字符串的形式输出
        System.out.println(ret);//所以这里输出是以字符串的形式输出
    }
    public static void main2(String[] args) {
        int[] array = {1,2,3,4,5,6};
        System.out.println(array[5]);//注意不要数组越界
    }


    public static void main1(String[] args) {
        //array 这个变量叫做引用变量 --> 简称为 “引用”
        int[] array = {1,2,3,4,5,6};
        int[] array2 = new int[]{1,2,3,4,5,6};
        //这种定义没区别
        /*
        new 指创建新的对象 --> 什么是对象后面说
        数组对象
         */
        int[] array3 = new int[10];
        //这种定义并没有初始化 当前指定的值 --> 默认里面的值为 0

        //对数组进行整体的初始化 只能实在定义这个数组的时候

        boolean[] flg = new boolean[3];//boolean 的0值默认为 false
    }
}
